@return: deferred
"""
ctrl = xend.blkif_create(self.dom, recreate=self.recreate)
- back = ctrl.getBackend(0)
+ back = ctrl.getBackendInterface(0)
return back.connect(recreate=self.recreate)
def dom_construct(self, dom, config):
@param index: vif index
@return: deferred
"""
- #if vm.netif_backend:
- # raise VmError('vif: vif in netif backend domain')
vif = vm.next_device_index('vif')
vmac = sxp.child_value(val, "mac")
ctrl = xend.netif_create(vm.dom, recreate=vm.recreate)
@param index: vbd index
@return: deferred
"""
- #if vm.blkif_backend:
- # raise VmError('vbd: vbd in blkif backend domain')
uname = sxp.child_value(val, 'uname')
if not uname:
raise VmError('vbd: Missing uname')
id = sxp.child_value(req, 'id')
if not id:
raise XendError('Missing console id')
+ id = int(id)
self.daemon.console_disconnect(id)
return ['ok']
return self.channelF.getDomChannel(dom)
def blkif_create(self, dom, recreate=0):
- """Create a block device interface controller.
+ """Create or get a block device interface controller.
Returns controller
"""
- return self.blkifCF.createInstance(dom, recreate=recreate)
+ return self.blkifCF.getController(dom)
def blkifs(self):
- return [ x.sxpr() for x in self.blkifCF.getInstances() ]
+ return [ x.sxpr() for x in self.blkifCF.getControllers() ]
def blkif_get(self, dom):
- return self.blkifCF.getInstanceByDom(dom)
+ return self.blkifCF.getControllerByDom(dom)
def blkif_dev(self, dom, vdev):
return self.blkifCF.getDomainDevice(dom, vdev)
Returns Deferred
"""
- ctrl = self.blkifCF.getInstanceByDom(dom)
+ ctrl = self.blkifCF.getControllerByDom(dom)
if not ctrl:
raise XendError('No blkif controller: %d' % dom)
d = ctrl.attachDevice(config, vdev, mode, segment, recreate=recreate)
return d
def netif_create(self, dom, recreate=0):
- """Create a network interface controller.
+ """Create or get a network interface controller.
"""
- return self.netifCF.createInstance(dom, recreate=recreate)
+ return self.netifCF.getController(dom)
def netifs(self):
- return [ x.sxpr() for x in self.netifCF.getInstances() ]
+ return [ x.sxpr() for x in self.netifCF.getControllers() ]
def netif_get(self, dom):
- return self.netifCF.getInstanceByDom(dom)
+ return self.netifCF.getControllerByDom(dom)
def netif_dev_create(self, dom, vif, config, recreate=0):
"""Create a network device.
"""
- ctrl = self.netifCF.getInstanceByDom(dom)
+ ctrl = self.netifCF.getControllerByDom(dom)
if not ctrl:
raise XendError('No netif controller: %d' % dom)
d = ctrl.attachDevice(vif, config, recreate=recreate)
def console_create(self, dom, console_port=None):
"""Create a console for a domain.
"""
- console = self.consoleCF.getInstanceByDom(dom)
+ console = self.consoleCF.getControllerByDom(dom)
if console is None:
- console = self.consoleCF.createInstance(dom, console_port)
+ console = self.consoleCF.createController(dom, console_port)
return console
def consoles(self):
- return [ c.sxpr() for c in self.consoleCF.getInstances() ]
+ return [ c.sxpr() for c in self.consoleCF.getControllers() ]
def get_consoles(self):
- return self.consoleCF.getInstances()
+ return self.consoleCF.getControllers()
def get_console(self, id):
- return self.consoleCF.getInstance(id)
+ return self.consoleCF.getControllerByIndex(id)
def get_domain_console(self, dom):
- return self.consoleCF.getInstanceByDom(dom)
+ return self.consoleCF.getControllerByDom(dom)
def console_disconnect(self, id):
"""Disconnect any connected console client.
def domain_shutdown(self, dom, reason):
"""Shutdown a domain.
"""
- ctrl = self.domainCF.getInstanceByDom(dom)
+ dom = int(dom)
+ ctrl = self.domainCF.getController(dom)
if not ctrl:
- raise XendError('No domain controller: %d' % dom)
+ raise XendError('No domain controller: %s' % dom)
ctrl.shutdown(reason)
return 0
from messages import *
class BlkifBackendController(controller.BackendController):
- """ Handler for the 'back-end' channel to a device driver domain.
- Must be connected using connect() before it can be used.
- Do not create directly - use getBackend() on the BlkifController.
+ """ Handler for the 'back-end' channel to a block device driver domain.
"""
- def __init__(self, ctrl, dom, handle):
- controller.BackendController.__init__(self, ctrl, dom, handle)
- self.connected = 0
- self.evtchn = None
- self.handle = handle
+ def __init__(self, factory, dom):
+ controller.BackendController.__init__(self, factory, dom)
self.addMethod(CMSG_BLKIF_BE,
CMSG_BLKIF_BE_DRIVER_STATUS_CHANGED,
self.recv_be_driver_status_changed)
self.registerChannel()
- def __str__(self):
- return '<BlkifBackendController %d %d>' % (self.controller.dom, self.dom)
-
def recv_be_driver_status_changed(self, msg, req):
"""Request handler for be_driver_status_changed messages.
val = unpackMsg('blkif_be_driver_status_changed_t', msg)
status = val['status']
+class BlkifBackendInterface(controller.BackendInterface):
+ """ Handler for the 'back-end' channel to a block device driver domain
+ on behalf of a front-end domain.
+ Must be connected using connect() before it can be used.
+ Do not create directly - use getBackendInterface() on the BlkifController.
+ """
+
+ def __init__(self, ctrl, dom, handle):
+ controller.BackendInterface.__init__(self, ctrl, dom, handle)
+ self.connected = 0
+ self.evtchn = None
+
+ def __str__(self):
+ return '<BlkifBackendInterface %d %d>' % (self.controller.dom, self.dom)
+
def connect(self, recreate=0):
- """Connect the controller to the blkif control interface.
+ """Connect to the blkif control interface.
@param recreate: true if after xend restart
@return: deferred
"""
def cb_destroy(val):
self.send_be_destroy()
+ self.close()
d = defer.Deferred()
d.addCallback(cb_destroy)
self.send_be_disconnect(response=d)
'evtchn' : self.evtchn['port2'] })
self.controller.writeRequest(msg, response=response)
-class BlkifControllerFactory(controller.ControllerFactory):
+class BlkifControllerFactory(controller.SplitControllerFactory):
"""Factory for creating block device interface controllers.
"""
def __init__(self):
- controller.ControllerFactory.__init__(self)
+ controller.SplitControllerFactory.__init__(self)
- def createInstance(self, dom, recreate=0):
+ def createController(self, dom, recreate=0):
"""Create a block device controller for a domain.
@param dom: domain
@return: block device controller
@rtype: BlkifController
"""
- blkif = self.getInstanceByDom(dom)
+ blkif = self.getControllerByDom(dom)
if blkif is None:
blkif = BlkifController(self, dom)
- self.addInstance(blkif)
+ self.addController(blkif)
return blkif
+ def createBackendController(self, dom):
+ """Create a block device backend controller.
+
+ @param dom: backend domain
+ @return: backend controller
+ """
+ return BlkifBackendController(self, dom)
+
+ def createBackendInterface(self, ctrl, dom, handle):
+ """Create a block device backend interface.
+
+ @param ctrl: controller
+ @param dom: backend domain
+ @param handle: interface handle
+ @return: backend interface
+ """
+ return BlkifBackendInterface(ctrl, dom, handle)
+
def getDomainDevices(self, dom):
"""Get the block devices for a domain.
@return: devices
@rtype: [device]
"""
- blkif = self.getInstanceByDom(dom)
+ blkif = self.getControllerByDom(dom)
return (blkif and blkif.getDevices()) or []
def getDomainDevice(self, dom, vdev):
@return: device
@rtype: device
"""
- blkif = self.getInstanceByDom(dom)
+ blkif = self.getControllerByDom(dom)
return (blkif and blkif.getDevice(vdev)) or None
class BlkDev(controller.SplitDev):
"""Attach the device to its controller.
"""
- backend = self.getBackend()
+ backend = self.getBackendInterface()
d1 = backend.connect()
d2 = defer.Deferred()
d2.addCallback(self.send_be_vbd_create)
def send_be_vbd_create(self, val):
d = defer.Deferred()
d.addCallback(self.respond_be_vbd_create)
- backend = self.getBackend()
+ backend = self.getBackendInterface()
msg = packMsg('blkif_be_vbd_create_t',
{ 'domid' : self.controller.dom,
'blkif_handle' : backend.handle,
def send_be_vbd_grow(self):
d = defer.Deferred()
- backend = self.getBackend()
+ backend = self.getBackendInterface()
msg = packMsg('blkif_be_vbd_grow_t',
{ 'domid' : self.controller.dom,
'blkif_handle' : backend.handle,
def send_be_vbd_destroy(self, response=None):
log.debug('>BlkDev>send_be_vbd_destroy> dom=%d vdev=%d',
self.controller.dom, self.vdev)
- backend = self.getBackend()
+ backend = self.getBackendInterface()
msg = packMsg('blkif_be_vbd_destroy_t',
{ 'domid' : self.controller.dom,
'blkif_handle' : backend.handle,
def __init__(self, factory, dom):
"""Create a block device controller.
- Do not call directly - use createInstance() on the factory instead.
+ Do not call directly - use createController() on the factory instead.
"""
controller.SplitController.__init__(self, factory, dom)
self.devices = {}
val = ['blkif', ['dom', self.dom]]
return val
- def createBackend(self, dom, handle):
- return BlkifBackendController(self, dom, handle)
-
def getDevices(self):
return self.devices.values()
dev.destroy()
def destroyBackends(self):
- for backend in self.getBackends():
+ for backend in self.getBackendInterfaces():
backend.destroy()
def recv_fe_driver_status_changed(self, msg, req):
def recv_fe_interface_connect(self, msg, req):
val = unpackMsg('blkif_fe_interface_connect_t', msg)
handle = val['handle']
- backend = self.getBackendByHandle(handle)
+ backend = self.getBackendInterfaceByHandle(handle)
if backend:
backend.connectInterface(val)
else:
"""Factory for creating console controllers.
"""
- def createInstance(self, dom, console_port=None):
+ def createController(self, dom, console_port=None):
if console_port is None:
console_port = CONSOLE_PORT_BASE + dom
- for c in self.getInstances():
+ for c in self.getControllers():
if c.console_port == console_port:
raise XendError('console port in use: ' + str(console_port))
console = ConsoleController(self, dom, console_port)
- self.addInstance(console)
+ self.addController(console)
log.info("Created console id=%s domain=%d port=%d",
console.idx, console.dom, console.console_port)
eserver.inject('xend.console.create',
def consoleClosed(self, console):
log.info("Closed console id=%s", console.idx)
eserver.inject('xend.console.close', console.idx)
- self.delInstance(console)
+ self.delController(console)
class ConsoleController(controller.Controller):
"""Console controller for a domain.
class ControllerFactory:
"""Abstract class for factories creating controllers for a domain.
- Maintains a table of instances.
+ Maintains a table of controllers.
- @ivar instances: mapping of index to controller instance
- @type instances: {String: Controller}
+ @ivar controllers: mapping of index to controller instance
+ @type controllers: {String: Controller}
@ivar dom: domain
@type dom: int
"""
def __init__(self):
- self.instances = {}
- self.backends = {}
- self.dom = 0
+ self.controllers = {}
- def addInstance(self, instance):
+ def addController(self, controller):
"""Add a controller instance (under its index).
"""
- self.instances[instance.idx] = instance
+ self.controllers[controller.idx] = controller
- def getInstance(self, idx):
- """Get a controller instance from its index.
+ def getControllers(self):
+ """Get a list of all controllers.
"""
- return self.instances.get(idx)
+ return self.controllers.values()
- def getInstances(self):
- """Get a list of all controller instances.
+ def getControllerByIndex(self, idx):
+ """Get a controller from its index.
"""
- return self.instances.values()
+ return self.controllers.get(idx)
- def getInstanceByDom(self, dom):
- """Get the controller instance for the given domain.
+ def getControllerByDom(self, dom):
+ """Get the controller for the given domain.
@param dom: domain id
@type dom: int
@return: controller or None
"""
- for inst in self.instances.values():
+ for inst in self.controllers.values():
if inst.dom == dom:
return inst
return None
- def delInstance(self, instance):
- """Delete a controller instance from the table.
+ def getController(self, dom):
+ """Create or find the controller for a domain.
- @param instance: controller instance
+ @param dom: domain
+ @return: controller
"""
- if instance.idx in self.instances:
- del self.instances[instance.idx]
-
- def createInstance(self, dom, recreate=0):
- """Create an instance. Define in a subclass.
+ ctrl = self.getControllerByDom(dom)
+ if ctrl is None:
+ ctrl = self.createController(dom)
+ self.addController(ctrl)
+ return ctrl
+
+ def createController(self, dom):
+ """Create a controller. Define in a subclass.
@param dom: domain
@type dom: int
- @param recreate: true if the instance is being recreated (after xend restart)
- @type recreate: int
@return: controller instance
@rtype: Controller (or subclass)
"""
raise NotImplementedError()
- def instanceClosed(self, instance):
- """Callback called when an instance is closed (usually by the instance).
+ def delController(self, controller):
+ """Delete a controller instance from the table.
+
+ @param controller: controller instance
+ """
+ if controller.idx in self.controllers:
+ del self.controllers[controller.idx]
+
+ def controllerClosed(self, controller):
+ """Callback called when a controller is closed (usually by the controller).
- @param instance: controller instance
+ @param controller: controller instance
"""
- self.delInstance(instance)
+ self.delController(controller)
class Controller(CtrlMsgRcvr):
"""Abstract class for a device controller attached to a domain.
"""The controller channel has been lost.
"""
self.deregisterChannel()
- self.factory.instanceClosed(self)
+ self.factory.controllerClosed(self)
+
+class SplitControllerFactory(ControllerFactory):
+ """Abstract class for factories creating split controllers for a domain.
+ Maintains a table of backend controllers.
+ """
+
+ def __init__(self):
+ ControllerFactory.__init__(self)
+ self.backendControllers = {}
+
+ def getBackendControllers(self):
+ return self.backendControllers.values()
+
+ def getBackendControllerByDomain(self, dom):
+ """Get the backend controller for a domain if there is one.
+
+ @param dom: backend domain
+ @return: backend controller
+ """
+ return self.backendControllers.get(dom)
+
+ def getBackendController(self, dom):
+ """Get the backend controller for a domain, creating
+ if necessary.
+
+ @param dom: backend domain
+ @return: backend controller
+ """
+ b = self.getBackendControllerByDomain(dom)
+ if b is None:
+ b = self.createBackendController(dom)
+ self.backendControllers[b.dom] = b
+ return b
+
+ def createBackendController(self, dom):
+ """Create a backend controller. Define in a subclass.
+
+ @param dom: backend domain
+ @return: backend controller
+ """
+ raise NotImplementedError()
+
+ def delBackendController(self, ctrlr):
+ """Remove a backend controller.
+
+ @param ctrlr: backend controller
+ """
+ if ctrlr.dom in self.backendControllers:
+ del self.backendControllers[ctrlr.dom]
+
+ def backendControllerClosed(self, ctrlr):
+ """Callback called when a backend is closed.
+ """
+ self.delBackendController(ctrlr)
+
+ def createBackendInterface(self, ctrl, dom, handle):
+ """Create a backend interface. Define in a subclass.
+
+ @param ctrl: frontend controller
+ @param dom: backend domain
+ @return: backend interface
+ """
+ raise NotImplementedError()
-class BackendController(CtrlMsgRcvr):
+class BackendController(Controller):
"""Abstract class for a backend device controller attached to a domain.
- @ivar controller: frontend controller
- @type controller: Controller
- @ivar dom: domain
+ @ivar factory: backend controller factory
+ @type factory: BackendControllerFactory
+ @ivar dom: backend domain
@type dom: int
@ivar channel: channel to the domain
@type channel: Channel
"""
- def __init__(self, controller, dom, handle):
+ def __init__(self, factory, dom):
CtrlMsgRcvr.__init__(self)
- self.controller = controller
+ self.factory = factory
self.dom = int(dom)
- self.handle = handle
self.channel = None
+ self.backendInterfaces = {}
def close(self):
self.lostChannel()
def lostChannel(self):
self.deregisterChannel()
- self.controller.backendClosed(self)
+ self.backend.backendClosed(self)
+
+ def registerInterface(self, intf):
+ key = intf.getInterfaceKey()
+ self.backendInterfaces[key] = intf
+
+ def deregisterInterface(self, intf):
+ key = intf.getInterfaceKey()
+ if key in self.backendInterfaces:
+ del self.backendInterfaces[key]
+
+ def getInterface(self, dom, handle):
+ key = (dom, handle)
+ return self.backendInterfaces.get(key)
+
+
+ def createBackendInterface(self, ctrl, dom, handle):
+ """Create a backend interface. Define in a subclass.
+
+ @param ctrl: controller
+ @param dom: backend domain
+ @param handle: backend handle
+ """
+ raise NotImplementedError()
+
+
+class BackendInterface:
+ """Abstract class for a domain's interface onto a backend controller.
+ """
+
+ def __init__(self, controller, dom, handle):
+ """
+
+ @param controller: front-end controller
+ @param dom: back-end domain
+ @param handle: back-end interface handle
+ """
+ self.factory = controller.factory
+ self.controller = controller
+ self.dom = int(dom)
+ self.handle = handle
+ self.backend = self.getBackendController()
+
+ def registerInterface(self):
+ self.backend.registerInterface(self)
+
+ def getInterfaceKey(self):
+ return (self.controller.dom, self.handle)
+
+ def getBackendController(self):
+ return self.factory.getBackendController(self.dom)
+
+ def writeRequest(self, msg, response=None):
+ return self.backend.writeRequest(msg, response=response)
+
+ def close(self):
+ self.backend.deregisterInterface(self)
+ self.controller.backendInterfaceClosed(self)
class SplitController(Controller):
"""Abstract class for a device controller attached to a domain.
- A SplitController manages a BackendController for each backend domain
+ A SplitController manages a BackendInterface for each backend domain
it has at least one device for.
"""
def __init__(self, factory, dom):
Controller.__init__(self, factory, dom)
- self.backends = {}
+ self.backendInterfaces = {}
self.backendHandle = 0
- def getBackends(self):
- return self.backends.values()
+ def getBackendInterfaces(self):
+ return self.backendInterfaces.values()
- def getBackendByHandle(self, handle):
- for b in self.getBackends():
+ def getBackendInterfaceByHandle(self, handle):
+ for b in self.getBackendInterfaces():
if b.handle == handle:
return b
return None
- def getBackendByDomain(self, dom):
- return self.backends.get(dom)
+ def getBackendInterfaceByDomain(self, dom):
+ return self.backendInterfaces.get(dom)
- def getBackend(self, dom):
- """Get the backend controller for a domain.
+ def getBackendInterface(self, dom):
+ """Get the backend interface for a domain.
@param dom: domain
@return: backend controller
"""
- b = self.getBackendByDomain(dom)
+ b = self.getBackendInterfaceByDomain(dom)
if b is None:
handle = self.backendHandle
self.backendHandle += 1
- b = self.createBackend(dom, handle)
- self.backends[b.dom] = b
+ b = self.factory.createBackendInterface(self, dom, handle)
+ b.registerInterface()
+ self.backendInterfaces[b.dom] = b
return b
- def createBackend(self, dom, handle):
- """Create a backend controller. Define in a subclass.
-
- @param dom: domain
- @param handle: controller handle
- """
- raise NotImplementedError()
-
- def delBackend(self, ctrlr):
+ def delBackendInterface(self, ctrlr):
"""Remove a backend controller.
@param ctrlr: backend controller
"""
- if ctrlr.dom in self.backends:
- del self.backends[ctrlr.dom]
+ if ctrlr.dom in self.backendInterfaces:
+ del self.backendInterfaces[ctrlr.dom]
- def backendClosed(self, ctrlr):
+ def backendInterfaceClosed(self, ctrlr):
"""Callback called when a backend is closed.
"""
- self.delBackend(ctrlr)
+ self.delBackendInterface(ctrlr)
class Dev:
"""Abstract class for a device attached to a device controller.
Dev.__init__(self, idx, controller)
self.backendDomain = 0
- def getBackend(self):
- return self.controller.getBackend(self.backendDomain)
+ def getBackendInterface(self):
+ return self.controller.getBackendInterface(self.backendDomain)
"""Factory for creating domain controllers.
"""
- def createInstance(self, dom):
+ def createController(self, dom):
"""Create a domain controller.
dom domain
returns domain controller
"""
- d = DomainController(self, dom)
- self.addInstance(d)
- return d
-
- def getInstanceByDom(self, dom):
- """Get a domain controller for a domain, creating if necessary.
-
- dom domain
-
- returns domain controller
- """
- for inst in self.instances.values():
- if inst.dom == dom:
- return inst
- inst = self.createInstance(dom)
- return inst
-
+ return DomainController(self, dom)
class DomainController(controller.Controller):
"""Generic controller for a domain.
from messages import *
class NetifBackendController(controller.BackendController):
- """Handler for the 'back-end' channel to a device driver domain.
+ """Handler for the 'back-end' channel to a network device driver domain.
"""
- def __init__(self, ctrl, dom, handle):
- controller.BackendController.__init__(self, ctrl, dom, handle)
+ def __init__(self, ctrl, dom):
+ controller.BackendController.__init__(self, ctrl, dom)
self.addMethod(CMSG_NETIF_BE,
CMSG_NETIF_BE_DRIVER_STATUS_CHANGED,
self.recv_be_driver_status_changed)
val = unpackMsg('netif_be_driver_status_changed_t', msg)
status = val['status']
-class NetifControllerFactory(controller.ControllerFactory):
+class NetifBackendInterface(controller.BackendInterface):
+ """Handler for the 'back-end' channel to a network device driver domain
+ on behalf of a front-end domain.
+
+ Each network device is handled separately, so we add no functionality
+ here.
+ """
+
+ pass
+
+class NetifControllerFactory(controller.SplitControllerFactory):
"""Factory for creating network interface controllers.
"""
def __init__(self):
- controller.ControllerFactory.__init__(self)
+ controller.SplitControllerFactory.__init__(self)
- def createInstance(self, dom, recreate=0):
- """Create or find the network interface controller for a domain.
+ def createController(self, dom):
+ """Create a network interface controller for a domain.
@param dom: domain
- @param recreate: if true this is a recreate (xend restarted)
@return: netif controller
"""
- netif = self.getInstanceByDom(dom)
- if netif is None:
- netif = NetifController(self, dom)
- self.addInstance(netif)
- return netif
+ return NetifController(self, dom)
+
+ def createBackendController(self, dom):
+ """Create a network device backend controller.
+
+ @param dom: backend domain
+ @return: backend controller
+ """
+ return NetifBackendController(self, dom)
+
+ def createBackendInterface(self, ctrl, dom, handle):
+ """Create a network device backend interface.
+
+ @param ctrl: controller
+ @param dom: backend domain
+ @param handle: interface handle
+ @return: backend interface
+ """
+ return NetifBackendInterface(ctrl, dom, handle)
def getDomainDevices(self, dom):
- """Get the network device controllers for a domain.
+ """Get the network devices for a domain.
@param dom: domain
@return: netif controller list
"""
- netif = self.getInstanceByDom(dom)
+ netif = self.getControllerByDom(dom)
return (netif and netif.getDevices()) or []
def getDomainDevice(self, dom, vif):
@param vif: virtual interface index
@return: NetDev
"""
- netif = self.getInstanceByDom(dom)
+ netif = self.getControllerByDom(dom)
return (netif and netif.getDevice(vif)) or None
class NetDev(controller.SplitDev):
{ 'domid' : self.controller.dom,
'netif_handle' : self.vif,
'mac' : self.mac })
- self.getBackend().writeRequest(msg, response=d)
+ self.getBackendInterface().writeRequest(msg, response=d)
return d
def respond_be_create(self, msg):
"""
def cb_destroy(val):
self.send_be_destroy()
+ self.getBackendInterface().close()
log.debug("Destroying vif domain=%d vif=%d", self.controller.dom, self.vif)
self.vifctl('down')
d = self.send_be_disconnect()
msg = packMsg('netif_be_disconnect_t',
{ 'domid' : self.controller.dom,
'netif_handle' : self.vif })
- self.getBackend().writeRequest(msg, response=d)
+ self.getBackendInterface().writeRequest(msg, response=d)
return d
def send_be_destroy(self, response=None):
{ 'domid' : self.controller.dom,
'netif_handle' : self.vif })
self.controller.delDevice(self.vif)
- self.getBackend().writeRequest(msg, response=response)
+ self.getBackendInterface().writeRequest(msg, response=response)
def recv_fe_interface_connect(self, val, req):
if not req: return
'rx_shmem_frame' : val['rx_shmem_frame'] })
d = defer.Deferred()
d.addCallback(self.respond_be_connect)
- self.getBackend().writeRequest(msg, response=d)
+ self.getBackendInterface().writeRequest(msg, response=d)
def respond_be_connect(self, msg):
val = unpackMsg('netif_be_connect_t', msg)
self.recv_fe_interface_connect)
self.registerChannel()
- def createBackend(self, dom, handle):
- return NetifBackendController(self, dom, handle)
-
def sxpr(self):
val = ['netif', ['dom', self.dom]]
return val
projects / xen.git / commitdiff